import cover2Api from '@/api/cover2'
// 查询表头深度并动态添加分类表头
export const addCategoryHeader = data => {
  let maxDepth = 1 // 假设至少有一个层级（根节点
  // 递归函数，用于遍历树形结构
  function traverse(node, currentDepth) {
    if (node.children && node.children.length > 0) {
      // 如果有子节点，则遍历子节点
      node.children.forEach(childNode => {
        const newDepth = currentDepth + 1
        maxDepth = Math.max(maxDepth, newDepth) // 更新最大深度
        traverse(childNode, newDepth) // 递归遍历子节点
      })
    }
  }
  // 遍历根节点的所有子节点
  data.forEach(rootNode => {
    traverse(rootNode, 1) // 从根节点开始，深度为1
  })
  // return maxDepth - 2
  return getCategoryStructure(maxDepth - 2)
}

// 动态添加一二级分类表头
export const getCategoryStructure = level => {
  const baseChild = {
    title: '应用名称(全量清单)',
    align: 'center',
    fixed: 'left',
    children: [
      {
        title: '建成状态',
        key: 'app',
        align: 'center',
        fixed: 'left',
        width: 150,
        renderHeader: (h, params) => {
          return h('div', null, [
            '建成状态',
            h(
              'Tooltip',
              {
                props: {
                  transfer: true,
                  placement: 'right',
                  maxWidth: '200',
                  content: '数字化应用业务实体覆盖数大于1则为√，否则为O'
                }
              },
              [
                h('Icon', {
                  props: {
                    type: 'ios-help-circle-outline'
                  },
                  style: {
                    fontSize: '16px'
                  }
                })
              ]
            )
          ])
        }
      }
    ]
  }
  if (level === 1) {
    return {
      title: '一级分类',
      align: 'center',
      fixed: 'left',
      children: [baseChild]
    }
  } else if (level === 2) {
    return {
      title: '一级分类',
      align: 'center',
      fixed: 'left',
      children: [
        {
          title: '二级分类',
          align: 'center',
          fixed: 'left',
          children: [baseChild]
        }
      ]
    }
  } else if (level === 3) {
    return {
      title: '一级分类',
      align: 'center',
      fixed: 'left',
      children: [
        {
          title: '二级分类',
          align: 'center',
          fixed: 'left',
          children: [
            {
              title: '三级分类',
              align: 'center',
              fixed: 'left',
              children: [baseChild]
            }
          ]
        }
      ]
    }
  } else if (level === 4) {
    return {
      title: '四级分类',
      align: 'center',
      fixed: 'left',
      children: [
        {
          title: '二级分类',
          align: 'center',
          fixed: 'left',
          children: [
            {
              title: '三级分类',
              align: 'center',
              fixed: 'left',
              children: [
                {
                  title: '四级分类',
                  align: 'center',
                  fixed: 'left',
                  children: [baseChild]
                }
              ]
            }
          ]
        }
      ]
    }
  }

  // 如果传入的 level 不符合预期，可以返回一个错误或者默认对象
  return null // 或者抛出一个错误
}

export const renameLastLevelToApp = (data, maxLevel) => {
  return data.map(item => {
    const newObj = { ...item }
    // 找到最后一个以'level'开头的属性名
    const levelKeys = Object.keys(newObj)
      .filter(key => key.startsWith('level'))
      .sort((a, b) => parseInt(b.slice(5), 10) - parseInt(a.slice(5), 10))
    //补齐level
    let parentValue = newObj[levelKeys[levelKeys.length > 1 ? 1 : 0]]
    for (let i = maxLevel; i > levelKeys.length; i--) {
      newObj['level' + i] = parentValue
    }
    newObj.app = newObj['level' + maxLevel]
    delete newObj['level' + maxLevel]
    // 返回修改后的对象
    return newObj
  })
}

// 展开表格数据获取value,然后修改最大level的key
export const flattenData = data => {
  let maxLevel = 1
  const flatRes = data.map(item => {
    const newData = {}
    // 给数据添加cellClassName属性，用来渲染背景颜色
    const cellClassName = {}
    for (const key in item) {
      if (key.startsWith('level')) {
        const level = parseInt(key.slice(5))
        if (level > maxLevel) {
          maxLevel = level
        }
      }
      if (Object.prototype.hasOwnProperty.call(item, key)) {
        const value = item[key]
        if (typeof value === 'object' && value !== null && 'value' in value) {
          // 如果属性的值是一个对象，并且该对象有 'value' 属性
          newData[key] = value.value
          if (value.status === 1) {
            cellClassName[key] = 'green'
          } else if (value.status === 2) {
            cellClassName[key] = 'red'
          } else if (value.status === 3) {
            cellClassName[key] = 'yellow'
          }
        } else {
          // 如果属性的值不是对象或者没有 'value' 属性，直接赋值
          newData[key] = value
        }
      }
    }
    newData['cellClassName'] = cellClassName
    return newData
  })
  return renameLastLevelToApp(flatRes, maxLevel)
}

const handleInput = (event, index, columnKey, tableData) => {
  // 获取当前输入值
  const currentValue = event.toString()
  // 使用正则表达式只允许数字和'-'
  const regex = /^(-$|0?|[1-9]\d*)$/
  const regex2 = /^-(-$|0?|[1-9]\d*)$/
  // 如果输入值匹配正则表达式，则更新数据
  if (regex.test(currentValue)) {
    tableData[index][columnKey] = currentValue
    if (currentValue == '') {
      tableData[index][columnKey] = '-'
    }
  } else {
    if (regex2.test(currentValue)) {
      tableData[index][columnKey] = currentValue.slice(1)
    } else {
      // 如果不匹配，找到最后一个匹配的位置
      for (let i = 0; i < currentValue.length; i++) {
        if (!regex.test(currentValue.slice(0, i + 1))) {
          break
        }
      }
    }
  }
}
const handleBlur = (event, item) => {
  let params = {
    id: item.id,
    value: event.target.value
  }
  cover2Api.updateData(params).then(res => {
    if (res.code === 200) {
      window.$app.$message.success({
        content: '保存成功',
        duration: 1
      })
    }
  })
}
// 递归添加render函数，给表格渲染input框
export const addRenderToColumns = (columns, getTableData, canEdit, originalData, page) => {
  // 递归函数，用于遍历所有子columns
  function addRenderRecursively(cols) {
    cols.forEach(col => {
      // 如果col是最后一个层级（即没有children），则添加render函数
      if (!col.children) {
        col.render = (h, { column, row, index }) => {
          const tableData = getTableData()
          // console.log("value", tableData[index], column.key)
          if (column.writeable && canEdit) {
            return h('el-input', {
              attrs: {
                value: tableData[index][column.key]
              },
              on: {
                input: event => handleInput(event, index, column.key, tableData),
                blur: event =>
                  handleBlur(event, originalData[(page.currentPage - 1) * page.currentPageSize + index][column.key])
              }
            })
          }
          if ('orderNum' !== column.key && /^\d+$/.test(row[column.key])) {
            return h('div', [
              h('Icon', {
                props: {
                  type: row[column.key] > 0 ? 'md-checkmark' : 'md-radio-button-off',
                  size: 20,
                  color: row[column.key] > 0 ? '#00C600' : '#B85913'
                }
              })
            ])
          }
          return h('span', row[column.key])
        }
      } else {
        // 如果col有children，则递归调用自身
        addRenderRecursively(col.children)
      }
    })
  }
  // 调用递归函数
  addRenderRecursively(columns)

  // 返回修改后的columns数组
  return columns
}

// 添加o或√的icon
export const addNewChildrenToLowestLevel = (columns, sumData) => {
  columns.forEach(column => {
    if (column.children && column.children.length) {
      addNewChildrenToLowestLevel(column.children, sumData) // 递归处理子项
    } else {
      // 如果没有 children，说明是最底层，添加新的 children 数组
      const newChild = {
        key: column.key, // 使用当前对象的 key
        writeable: true,
        align: 'center',
        status: 0,
        minWidth: 200,
        renderHeader: (h, params) => {
          return h('div', [
            h('Icon', {
              props: {
                type: sumData[column.key] > 0 ? 'md-checkmark' : 'md-radio-button-off',
                size: 20,
                color: sumData[column.key] > 0 ? '#00C600' : '#B85913'
              }
            })
          ])
        }
      }
      column.children = [newChild] // 添加新的 children 数组
    }
  })
  return columns
}

// 查找最多level个数,并渲染表头个数
export const getMaxLevelHeader = data => {
  let maxLevel = 0

  // 遍历数组中的每个对象
  data.forEach(item => {
    const keys = Object.keys(item).filter(key => key.startsWith('level'))
    // 找到当前对象中的最大 level 索引（转换为数字后）
    const currentMaxLevel = Math.max(...keys.map(key => parseInt(key.slice(5), 10) || 0))
    // 更新全局的最大 level 索引
    maxLevel = Math.max(maxLevel, currentMaxLevel)
  })
  return maxLevelHeader(maxLevel)
}

// 根据最大level数渲染表头个数
export const maxLevelHeader = num => {
  const children = [
    {
      title: '十四五数字化应用蓝图',
      key: 'level1',
      align: 'center',
      width: 100,
      fixed: 'left'
    },
    {
      title: '序号',
      key: 'orderNum',
      align: 'center',
      width: 50,
      fixed: 'left'
    }
  ]
  if (num > 2) {
    // 组织大于2级时，添加部门
    for (let i = 1; i < num; i++) {
      const baseHeader = {
        title: i + '级部门',
        key: 'level' + i,
        align: 'center',
        width: 100,
        fixed: 'left'
      }
      children.push(baseHeader)
    }
  }
  return {
    title: '关键业务环节',
    align: 'center',
    width: 100,
    fixed: 'left',
    children
  }
}

// 如果level的data相同，合并单元格
export const getMergeNum = (data, contentType) => {
  //页面展示的数据，不一定是全部的数据，所以每次都清空之前存储的 保证遍历的数据是最新的数据。以免造成数据渲染混乱
  let spanArr = []
  let pos = 0
  //遍历数据
  data.forEach((item, index) => {
    //判断是否是第一项
    if (index === 0) {
      spanArr.push(1)
      pos = 0
    } else {
      //不是第一项时，就根据标识去存储
      if (data[index][contentType] === data[index - 1][contentType]) {
        // 查找到符合条件的数据时每次要把之前存储的数据+1
        spanArr[pos] += 1
        spanArr.push(0)
      } else {
        // 没有符合的数据时，要记住当前的index
        spanArr.push(1)
        pos = index
      }
    }
  })
  return spanArr
}

// 计算数据列的总和
export const getColumnSumData = tableData => {
  const sumData = {}
  tableData.forEach(item => {
    Object.keys(item).forEach(key => {
      if (typeof item[key] === 'object') {
        if (!Object.prototype.hasOwnProperty.call(sumData, key)) {
          sumData[key] = 0
        }
        sumData[key] += Number(item[key].value) || 0
      }
    })
  })
  return sumData
}

// 删除children为null的字段
export const removeNullChildren = data => {
  if (Array.isArray(data)) {
    return data.map(item => removeNullChildren(item))
  } else if (typeof data === 'object' && data !== null) {
    const newData = { ...data } // 浅拷贝对象
    if (newData.children === null) {
      delete newData.children // 如果children为null，则删除
    } else if (Array.isArray(newData.children)) {
      newData.children = newData.children.map(item => removeNullChildren(item)) // 递归处理children数组
    }
    return newData
  }
  return data // 如果不是数组或对象，直接返回原始值
}

// 给每个对象添加align
export const addAlignToObjects = data => {
  // 遍历数组中的每个对象
  data.forEach(obj => {
    // 添加align属性
    obj.align = 'center'

    // 如果对象有children属性并且是数组
    if (Array.isArray(obj.children)) {
      // 递归处理children数组
      addAlignToObjects(obj.children)
    }
  })

  // 返回修改后的数据（虽然原数组已经被修改，但返回以符合函数式编程风格）
  return data
}

// 遍历数组拿到下一个值
export const getNextValue = (array, targetValue) => {
  // 遍历数组并查找下一个值
  let found = false
  let nextValue = null
  for (let i = 0; i < array.length; i++) {
    if (array[i].value === targetValue) {
      // 如果找到了目标值，并且后面还有元素，则获取下一个值
      if (i < array.length - 1) {
        nextValue = array[i + 1].value
      }
      found = true
      break
    }
  }
  return nextValue
}

// 处理tableData,用来提交时传给后端
export const updateTableDataWithDealData = (updatedData, originalData, pageNum) => {
  // 假设 updatedData 和 originalData 的长度相同，并且顺序对应
  if (updatedData.length !== originalData.length) {
    throw new Error('updatedData and originalData must have the same length and corresponding order')
  }

  const data = updatedData.map((deal, index) => {
    const tableItem = originalData[index]
    const updatedItem = { ...tableItem } // 创建一个新的对象来避免直接修改原始对象

    // 遍历 deal 对象中的每个键
    for (const key in deal) {
      if (
        deal.hasOwnProperty(key) &&
        typeof deal[key] !== 'object' &&
        typeof tableItem[key] === 'object' &&
        tableItem[key].hasOwnProperty('value')
      ) {
        // 如果 deal 中的键存在，并且它的值不是对象，同时 tableItem 中的键对应的值是一个对象且包含 value 属性
        updatedItem[key] = { ...tableItem[key], value: deal[key] } // 更新 value 属性
      }
    }
    return updatedItem
  })
  console.log('data', data)
  const dealData = data.splice(pageNum, 10).map(item => {
    const orgCode = Object.values(item)[0].orgCode
    // 创建一个columns数组来存储转换后的对象
    const columns = []
    for (const key in item) {
      if (item.hasOwnProperty(key) && typeof item[key] === 'object') {
        // 将每个属性转换为具有sysCode, orgCode, 和 value 的对象
        const { orgCode: _, id, ...rest } = item[key]
        // if (columns.length > 5) {
        //   columns.splice(-1)
        // }
        columns.push({ sysCode: key, value: rest.value, orgCode, id: id || '' })

        // 将orgCode添加回每个对象
      }
    }
    // 返回一个包含columns和orgCode的对象
    return { columns, orgCode }
  })
  return dealData
}
